/*
 * CtrlAtividade.java
 * 
 * Projeto: Kruskal - SRAC
 * LEDS - Laboratório de Engenharia e Desenvolvimento de Software
 * IFES - Instituto Federal do Espírito Santo - Campus Serra.
 */
package srac.controleatividades.cci;

import com.lowagie.text.BadElementException;
import com.lowagie.text.DocumentException;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.*;
import org.zkoss.zk.ui.Executions;
import srac.controleatividades.cdp.*;
import srac.controleatividades.cgt.AplAtividade;
import srac.controleatividades.cgt.AplEmitirRelatorios;
import srac.controleatividades.cgt.ClassificadorAtividades;
import srac.controleatividades.cih.*;
import srac.controleatividades.cih.PagIncluirAtividadeEvento;
import srac.controleeventos.cdp.Evento;

/**
 *
 * @author Gabriel
 */
public class CtrlAtividade {
    public static final int SALVAR = 0;
    public static final int EDITAR = 1;
    public static final int CONSULTAR = 2;
    private PagEventosEtapa pagEventosEtapa;
    private PagEventosAtividade pagEventosAtividade;
    private PagEventosConferencia pagEventosConferencia;
    private PagFormularioConferencia pagFormularioConferencia;
    private PagEventosValidar pagEventosValidar;
    private PagFormularioValidar pagFormularioValidar;
    private PagRelatorioFinal pagRelatorioFinal;
    private PagConfirmarSubmissao pagConfirmarSubmissao;
    private PagIncluirAtividadeEvento pagIncluirAtividadeEvento;
    
    
    private static CtrlAtividade instance = null;

    private AplAtividade apl = AplAtividade.getInstance();
    private AplEmitirRelatorios aplEmitirRelatorios = AplEmitirRelatorios.getInstance();
    
    public static CtrlAtividade getInstance() {
        if (instance == null) {
            instance = new CtrlAtividade();
        }
        return instance;
    }

    public void setPagIncluirAtividadeEvento(PagIncluirAtividadeEvento pagIncluirAtividadeEvento) {
        this.pagIncluirAtividadeEvento = pagIncluirAtividadeEvento;
    }
    
    

    public void setPagRelatorioFinal(PagRelatorioFinal pagRelatorioFinal) {
        this.pagRelatorioFinal = pagRelatorioFinal;
    }

    public void setPagConfirmarSubmissao(PagConfirmarSubmissao pagConfirmarSubmissao) {
        this.pagConfirmarSubmissao = pagConfirmarSubmissao;
    }

    public void setPagEventosAtividade(PagEventosAtividade pagEventosAtividade) {
        this.pagEventosAtividade = pagEventosAtividade;
    }

    public PagEventosAtividade getPagEventosAtividade() {
        return pagEventosAtividade;
    }
    
    public void setPagEventosConferencia(PagEventosConferencia pagEventosConferencia) {
        this.pagEventosConferencia = pagEventosConferencia;
    }

    public void setPagFormularioConferencia(PagFormularioConferencia pagFormularioConferencia) {
        this.pagFormularioConferencia = pagFormularioConferencia;
    }

    public void setPagEventosValidar(PagEventosValidar pagEventosValidar) {
        this.pagEventosValidar = pagEventosValidar;
    }

    public void setPagFormularioValidar(PagFormularioValidar pagFormularioValidar) {
        this.pagFormularioValidar = pagFormularioValidar;
    }


    

    public void setPagEventosEtapa(PagEventosEtapa pagEventosEtapa) {
        this.pagEventosEtapa = pagEventosEtapa;
    }
    
    /**
     * Inclui uma nova Atividade Complementar
     * @param args
     * @return A atividade icluida ou Null caso haja algum erro
     */
    
    public AtividadeComplementar incluirAtividadeComplementar(ArrayList<Object> args) {
        AtividadeComplementar a = null;
        try {
            a = apl.incluirAtividadeComplementar(args);
            pagEventosAtividade.addAtividadeComplementar(a);
            pagEventosAtividade.setMensagemAviso("success", "Cadastro realizado com sucesso!");
        } 
        catch (Exception ex) {
            pagEventosAtividade.setMensagemAviso("error", "Erro ao cadastrar a Atividade Complementar!");
            System.err.println(ex.getMessage());
        }
        return a;
    }
    /**
     * Apaga uma Atividade Complementar
     * @param atividadeComplementar
     * @return Verdadeiro caso foi possivel Apagar a Atividade Complementar ou Falso caso contrário
     */

    public boolean apagarAtividadeComplementar(AtividadeComplementar atividadeComplementar) {
        try {
            return apl.apagarAtividadeComplementar(atividadeComplementar);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
        
    }
    
    /**
     * Altera uma Atividade Complementar
     * @param args
     * @return A nova Atividade Complementar modificada ou Null caso haja algum erro
     */

    public AtividadeComplementar alterarAtividadeComplementar(AtividadeComplementar args) {
        AtividadeComplementar a = null;
        try {
            a = apl.alterarAtividadeComplementar(args);
            pagEventosAtividade.refreshAtividadeComplementar(a);
            pagEventosAtividade.setMensagemAviso("success", "Atividade editada com sucesso!");
        } catch (Exception ex) {
            pagEventosAtividade.setMensagemAviso("error", "Erro ao editar a Atividade Complementar!");
            System.err.println(ex.getMessage());
        }
        return a;
    }
    
    
    /**
     * Obtem todas as Atividades Complementares cadastradas
     * @return Uma lista de Atividades Complementares ou Null caso haja algum erro
     */

    public List<AtividadeComplementar> obterAtividadesComplementares() {
        try {
            return apl.obterAtividadesComplementares();
        } 
         catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obtem todas as Atividades Complementares cadastradas da Etapa 'e'
     * @return Uma lista de Atividades Complementares ou Null caso haja algum erro
     */

    public List<AtividadeComplementar> obterAtividadesComplementares(Etapa e) {
        try {
            return apl.obterAtividadesComplementares(e);
        }  
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obter Atividades Complementares pelo TipoAtividade
     * @param t
     * @return Uma lista de Atividades ou Null caso haja algum erro
     */

    public List<AtividadeComplementar> obterAtividadesComplementares(TipoAtividade t) {
        try {
            return apl.obterAtividadesComplementares(t);
        }  
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obter as Atividades Complementares do Aluno 'a' na Etapa 'e'
     * @param a
     * @param e
     * @return Uma lista de Atividades ou Null caso haja algum erro
     */

    public List<AtividadeComplementar> obterAtividadesComplementares(Aluno a, Etapa e) {
        try {
            return apl.obterAtividadesComplementares(a,e); 
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obter as Atividades Complementares do Aluno
     * @param a
     * @return Uma lista de Atividades ou Null caso haja algum erro
     */

    public List<AtividadeComplementar> obterAtividadesComplementares(Aluno a) {
        try {
            return apl.obterAtividadesComplementares(a);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }  
    }
    
    /**
     * Obtem as Atividades Complementares do TipoAtividades com o Status 's'
     * @param t
     * @param s
     * @return Uma lista de Atividades ou Null caso haja algum erro
     */

    public List<AtividadeComplementar> obterAtividadesComplementares(TipoAtividade t, StatusAtividadeComplementar s) {
        try {
            return apl.obterAtividadesComplementares(t, s);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Abre a PagFormularioAtividade para incluir uma nova Atividade Complementar
     */

    public void abrirIncluirAtividadeComplementar() {
        Map map = new HashMap();
        map.put("tipo", CtrlAtividade.SALVAR);
        Executions.createComponents("/PagFormularioAtividade.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioAtividade para alterar uma Atividade Complementar
     */

    public void abrirEditarAtividadeComplementar(AtividadeComplementar atividadeComplementar) {
        Map map = new HashMap();
        map.put("tipo", CtrlAtividade.EDITAR);
        map.put("obj", atividadeComplementar);
        Executions.createComponents("/PagFormularioAtividade.zul", null, map);
    }
    /**
     * Abre a PagFormularioAtividade para consultar uma Atividade Complementar
     */

    public void abrirConsultarAtividadeComplementar(AtividadeComplementar atividadeComplementar) {
        Map map = new HashMap();
        Object put = map.put("tipo", CtrlAtividade.CONSULTAR);
        map.put("obj", atividadeComplementar);
        Executions.createComponents("/PagFormularioAtividade.zul", null, map);
    }

    /**
     * Muda o Status do Aluno
     * @param aluno
     * @param statusSubmissao 
     */

    public void mudarStatus(Aluno aluno, StatusSubmissao statusSubmissao) {
        try {
            apl.mudarStatus(aluno, statusSubmissao);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
    
    /**
     * Atualiza a lista de Atividades Complementares na PagEventosAtividade
     * @param list 
     */
    public void refreshAtividades(List<AtividadeComplementar> list){
        pagEventosAtividade.refreshAtividadeComplementar(list);
    }

    /**
     * Obtem as Atividades Complementares pelo TipoAtividade para validação (Em análise, aceitas, rejeitadas, aceitas modificadas)
     * @param obj
     * @return return Uma lista de Atividades
     */
    public List<AtividadeComplementar> obterAtividadesComplementaresValidacao(TipoAtividade obj) {
        return apl.obterAtividadesComplementaresValidacao(obj);
    }

    /**
     * Verifica se a Atividades Complementar 'obj' foi modificada
     * @param obj
     * @param atributosNovos
     * @return Verdadeiro caso tenha sido moficada ou Falso caso contrário
     */
    public boolean atividadeModificada(AtividadeComplementar obj, List<Object> atributosNovos) {
        return apl.atividadeModificada(obj, atributosNovos);
    }
      
    
    /**
     * Inclui um nova Etapa
     * @param args
     * @return A etapa incluida ou Null caso haja algum erro
     */
    public Etapa incluirEtapa(ArrayList<Object> args) {
        Etapa e = null;
        try {
            e = apl.incluirEtapa(args);
            pagEventosEtapa.addEtapa(e);
            pagEventosEtapa.setMensagemAviso("success", "Cadastro realizado com sucesso!");
        } catch (Exception ex) {
            pagEventosEtapa.setMensagemAviso("error", "Erro ao cadastrar a Etapa!");
            System.err.println(ex.getMessage());
        }
        return e;
    }
    
    /**
     * Apaga uma Etapa
     * @param Etapa
     * @return Verdadeiro caso foi possível apagar a Etapa ou Falso caso contrário
     */
    
    public boolean apagarEtapa(Etapa Etapa){
        try {
            return apl.apagarEtapa(Etapa);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
    }
    
    /**
     * Altera uma Etapa cadastrada
     * @param args
     * @return A Etapa modificada ou Null caso haj algum erro
     */
    public Etapa alterarEtapa(Etapa args) {
        Etapa e = null;
        try {
            e = apl.alterarEtapa(args);
            pagEventosEtapa.refreshEtapa(e);
            pagEventosEtapa.setMensagemAviso("success", "Cadastro editado com sucesso!");
        } 
        catch (Exception ex) {
            pagEventosEtapa.setMensagemAviso("error", "Erro ao editar a Etapa!");
            System.err.println(ex.getMessage());
        }
        return e;
    }
    
    /**
     * Obtem as Etapas cadastradas
     * @return Uma lista de Etapas ou Null caso haja algum erro
     */
    
    public List<Etapa> obterEtapas() {
        try {
            return apl.obterEtapas();
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obtem a Etapa Atual
     * @return A etapa ou Null caso não exista uma etapa atual
     */
    
    public Etapa obterEtapaAtual(){
        try {
            return apl.obterEtapaAtual();
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obtem a Próxima Etapa a ser iniciada
     * @return A etapa ou Null caso não exista uma etapa atual
     */
    
    public Etapa obterProximaEtapa() {
        try {
            return apl.obterProximaEtapa();
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Abre a PagFormularioEtapa para Incluir uma nova Etapa
     */

    public void abrirIncluirEtapa() {
        Map map = new HashMap();
        map.put("tipo", CtrlAtividade.SALVAR);
        Executions.createComponents("/PagFormularioEtapa.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioEtapa para Alterar uma Etapa
     */

    public void abrirEditarEtapa(Etapa etapa) {
        Map map = new HashMap();
        map.put("tipo", CtrlAtividade.EDITAR);
        map.put("obj", etapa);
        Executions.createComponents("/PagFormularioEtapa.zul", null, map);
    }
    
    /**
     * Obtem todos alunos que submeteram atividades
     * @return Uma lista de Alunos
     */
    
    public List<Aluno> obterAlunosComAtividadesSubmetidas() {
        return apl.obterAlunosComAtividadesSubmetidas();
    }
    
   
    
    /**
     * Abre a PagFormularioConferencia para a verificação dos ceriticados do Aluno
     * @param a 
     */
    public void abrirFormularioConferencia(Aluno a) {
        Map map = new HashMap();
        map.put("obj", a);
        Executions.createComponents("/PagFormularioConferencia.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioValidar para a validação das Atividades Complementare por TipoAtividade
     * @param t 
     */
    
    public void abrirFormularioValidar(TipoAtividade t) {
        Map map = new HashMap();
        map.put("obj", t);
        Executions.createComponents("/PagFormularioValidar.zul", null, map);
    }
    
   
    /**
     * Abre a PagConfirmarSubmissao para o Aluno Confirmar se Deseja Submeter as Atividades Selecionadas
     * @param l
     * @param aluno 
     */
    public void abrirConfirmarSubmissao(List<AtividadeComplementar> l, Aluno aluno) {
        Map map = new HashMap();
        map.put("atividades", l);
        map.put("obj", aluno);
        Executions.createComponents("/PagConfirmarSubmissao.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioValidarAtividade para o pedagogo Validar a Atividade Complementar podendo modifica-la
     * @param atividadeComplementar 
     */
    
    public void abrirFormularioValidarAtividade(AtividadeComplementar atividadeComplementar) {
        Map map = new HashMap();
        map.put("obj", atividadeComplementar);
        Executions.createComponents("/PagFormularioValidarAtividade.zul", null, map);
    }

    /**
     * Altera o status da Atividade Complementar para o que foi passado como parametro.
     * @param a Atividade Complementar
     * @param status Status para o qual se deseja alterar a Atividade
     */
    public void registrarResultadoConferencia(AtividadeComplementar a, StatusAtividadeComplementar status) {
        try {
            apl.registrarResultadoConferencia(a, status);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());

        }
    }
    
    /**
     * Registra o resultado do que a secretaria conferriu, verifica quantos pontos o aluno obteve com as atividades conferidas,
     * se for >=15 modifica o status para Atividades Conferidas, senão modifica para Atividades Conferidas Inapto
     * @param list
     * @param a
     * @return Verdadeiro se o aluno ficou com atividades conferidas ou Falso caso contrário
     */

    public boolean registrarResultado(List<AtividadeComplementar> atividades, Aluno obj) {
        
        try {
            pagEventosConferencia.setMensagemAviso("success", "Todas atividades conferidas");
            return apl.registrarResultado(atividades, obj);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
        
        
    }
    
    /**
     * Verifica se a etapa não está no intervalo de outra etapa cadastrada
     * @param inicioEtapa
     * @param fimEtapa
     * @return Verdadeiro se ela não está no intervalo de nenhuma outra etapa  ou Falso se ela está
     */
    
    public boolean validarEtapa(Calendar inicioEtapa, Calendar fimEtapa) {
        try {
            return apl.validarEtapa(inicioEtapa, fimEtapa);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
        
    }
    
    /**
     * Verifica se alguma etapa diferente da passada por paramêtro está no intervalo de outra etapa cadastrada
     * @param etapa
     * @param inicioEtapa
     * @param fimEtapa
     * @return Verdadeiro se ela não está no intervalo de nenhuma outra etapa  ou Falso se ela está
     */
    
    public boolean validarEtapa(Etapa etapa, Calendar inicioEtapa, Calendar fimEtapa) {
        try {
            return apl.validarEtapa(etapa, inicioEtapa, fimEtapa);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
        
    }
    
    /**
     * Verifica se as atividades podem ser submetidas
     * @param selecionados
     * @return 0 se a soma de todas as é >=15 e em alguma categoria o aluno teve mais de 10 pontos,
     * 1 se a soma de todas as é >=15 e em nenhuma categoria o aluno teve mais de 10 pontos,
     * 2 se a soma de todas as é menor do que 15 e em nenhuma categoria o aluno teve mais de 10 pontos,
     * 3 se a soma de todas as é menor do que 15 e em alguma categoria o aluno teve mais de 10 pontos.
     */

    public int verificarSubmissao(ArrayList<AtividadeComplementar> selecionados) {
        return apl.verificarSubmissao(selecionados);
    }
    
    /**
     * Modifica o status das atividades para submetidas e adiciona a etapa nelas
     * @param selecionadas 
     */

    public void submeterAtividades(ArrayList<AtividadeComplementar> selecionadas) {
        try {
            apl.submeterAtividades(selecionadas);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
    
    /**
     * Atualiza os Alunos na PagEventosConferencia
     * @param a 
     */
    
    public void refreshAluno(Aluno a){
        pagEventosConferencia.refreshAluno(a);
    }
    
    /**
     * Verifica se as datas estão no mesmo dia
     * @param c1
     * @param c2
     * @return Verdadeiro se as datas estão no mesmo dia ou Falso se estão em dias diferentes
     */
    public boolean comparaDatas(Calendar c1, Calendar c2)
    {
        return apl.comparaDatas(c1, c2);
    }
    
    /**
     * Modifica o status da atividade
     * @param a
     * @param status
     */

    public void registrarResultadoValidar(AtividadeComplementar a, StatusAtividadeComplementar status) {
        try {
            apl.registrarResultadoValidar(a, status);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
    
    /**
     * Altera uma Atividade Complementar na validação
     * @param args
     * @return A Atividade Complementar modificada ou Null caso haja algum erro
     */
    
    public AtividadeComplementar alterarAtividadeComplementarValidacao(AtividadeComplementar args) {
        AtividadeComplementar a = null;
        try {
            a = apl.alterarAtividadeComplementar(args);
            pagFormularioValidar.refreshAtividade(a);
            pagFormularioValidar.setMensagemAviso("success", "Atividade validada com sucesso!");
        } catch (Exception ex) {
            pagFormularioValidar.setMensagemAviso("error", "Erro ao validar a Atividade Complementar!");
            System.err.println(ex.getMessage());
        }
        return a;
    }
    
    /**
     * Verifica a etapa
     * @param obj
     * @return 0 se ela já foi finalizada, 1 se nenhuma atividades está vinculada com ela, se não for nenhuma das primeiras retorna 2
     */
    public int verificarEtapa(Etapa obj) {
        return apl.verificarEtapa(obj);
    }
    

    /**
     * Modifica o Status da Etapa
     * @param e
     * @param s 
     */
    public void iniciarDataEtapa(Etapa e, StatusEtapa s) {
        try {
            apl.alteraStatusEtapa(e, s);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
    /**
     * Gera o relatorio de Submissões do Aluno
     * @param obj
     * @return Verdadeiro caso foi possível gerar ou Falso caso contrário
     */
    
     public boolean gerarResultados(Aluno obj) {
        try {
            return aplEmitirRelatorios.gerarRelatorios(obj);
        } 
        catch (BadElementException ex) {
            System.err.println(ex.getMessage());
        } 
        catch (MalformedURLException ex) {
            System.err.println(ex.getMessage());
        } 
        catch (IOException ex) {
            System.err.println(ex.getMessage());
        } 
        catch (DocumentException ex) {
            System.err.println(ex.getMessage());
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
        
        return false;
     }
     
     /**
     * Gera a Tabela de Atividades
     */
     
     public void gerarTabelaAtividades()
     {
        try {
            aplEmitirRelatorios.gerarTabelaAtividades();
        } catch (Exception ex) {
            System.err.println("Erro em gerar a Tabela de Atividades!");
        }
     }
     
     /**
     * Dos alunos que estão com status de Atividades Conferidas, modifica-se o status das atividades conferidas para em análise, modifica-se a submetidas para registradas.
     */
    
    public void encerrarEtapaConferencia() {
        try {
            apl.encerrarEtapaConferencia();
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
    
    /**
     * Modifica o status dos alunos que conseguiram 15 pontos para atividades aceitas, e dos que não conseguiram para atividades pendentes
     */

    public void encerrarEtapaValidacao() {
        try {
            apl.encerrarEtapaValidacao();
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
    
    /**
     * Transforma um array de bytes cadastrados em PDF
     * @param arquivo
     * @param nome
     * @return O arquivo PDF recuperado
     */
    public File recuperaArquivoPDF(byte[] arquivo, String nome)
    {
        try {
            return aplEmitirRelatorios.recuperarArquivoPDF(arquivo, nome);
            
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
        
        
    }
    
    /**
     * Obtem todos os Relatorios Finais cadastrados
     * @return Uma lista de Relatorios Finais ou Null caso haja algum erro
     */
    
    public List<RelatorioFinal> obterRelatoriosFinal() {
        try {
            return apl.obterRelatorioFinal();
        } 
        catch (Exception ex) {
            return null;
        }
        
    }

    /**
     * Obtem o total de potos por categoria
     * @param obj
     * @param s
     * @return Uma lista de classificadores
     */
    public List<ClassificadorAtividades> obterTotaldePontosCategoria(Aluno obj, StatusAtividadeComplementar s) {
        return apl.obterTotaldePontosCategoria(obj, s);
    }
    
    /**
     * Separa as atividades em classificadores (Categoria, Creditos Requeridos, Total de atividades nessa categoria)
     * @param atividades
     * @return Uma lista de Classificadores
     */
    public List<ClassificadorAtividades> obterTotaldeClassificadores(List<AtividadeComplementar> l) {
        return apl.obterTotaldeClassificadores(l);
    }

    /**
     * Formata uma data para exibição na interface
     * @param data
     * @return Um String com a data formatada
     */
    public String formatarData(Calendar data) {
        return apl.formatarData(data);
    }

    /**
     * Se o dia atual está depois de uma data
     * @param data
     * @return Verdadeiro se está ou Falso senão está
     */
    public boolean passou(Calendar data) {
        return apl.passou(data);
    }

    /**
     * Verifica se existe algum relatório final cadastrado
     * @return Verdadeiro se existe ou Falso se n existe
     */
    public boolean verificarExistenciaRelatorio() {
        try {
            return apl.verificarExistenciaRelatorio();
        } catch (Exception ex) {
            System.err.println("Erro em verificar se existe um relatorio!");
            return false;
        }
    }
    
    
    public void abrirIncluirAtividadeEvento(Aluno a) {
        Map map = new HashMap();
        map.put("obj", a);
        Executions.createComponents("/PagIncluirAtividadeEvento.zul", null,map);
    }

    public void incluirAtividadeEvento(Evento e, Aluno a) {
        AtividadeComplementar atv = apl.incluirAtividadeEvento(e,a);
        if(atv!=null)
        {
            pagEventosAtividade.addAtividadeComplementar(atv);
            pagEventosAtividade.setMensagemAviso("success", "Atividade incluida com sucesso!");
        }
        else
        {
            pagEventosAtividade.setMensagemAviso("error", "Erro ao incluir a atividade!");
        }
    }

    public void refreshValidar() {
        pagEventosValidar.refresh();
    }

    

    
}
